/* THIS FILE IS AUTOMATICALLY GENERATED */
/* TestZeoFuncAPI.py 2007-03-31 21:36:07.390000 */

void calc_HF_ClipMap (ZMAP hMap, float ClipAlt, float SetAlt, int ClipMode, bool ShowProgress)
{
    static ZFUNC hFuncClipMap = NULL;
    
    if (hFuncClipMap == NULL)
        hFuncClipMap = theAPI.zeofunc_GetFunc("calc.HF.ClipMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarClipAlt = theAPI.list_CreateItem(hArgs, VarID_float, "ClipAlt");
    theAPI.var_SetValue(hVarClipAlt, &ClipAlt);

    ZVAR hVarSetAlt = theAPI.list_CreateItem(hArgs, VarID_float, "SetAlt");
    theAPI.var_SetValue(hVarSetAlt, &SetAlt);

    ZVAR hVarClipMode = theAPI.list_CreateItem(hArgs, VarID_int, "ClipMode");
    theAPI.var_SetValue(hVarClipMode, &ClipMode);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncClipMap, hArgs);
    return;
}

void calc_HF_ClampMap (ZMAP hMap, float MinAlt, float MaxAlt, bool ShowProgress)
{
    static ZFUNC hFuncClampMap = NULL;
    
    if (hFuncClampMap == NULL)
        hFuncClampMap = theAPI.zeofunc_GetFunc("calc.HF.ClampMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarMinAlt = theAPI.list_CreateItem(hArgs, VarID_float, "MinAlt");
    theAPI.var_SetValue(hVarMinAlt, &MinAlt);

    ZVAR hVarMaxAlt = theAPI.list_CreateItem(hArgs, VarID_float, "MaxAlt");
    theAPI.var_SetValue(hVarMaxAlt, &MaxAlt);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncClampMap, hArgs);
    return;
}

void calc_HF_ScaleMap (ZMAP hMap, float val, bool ShowProgress)
{
    static ZFUNC hFuncScaleMap = NULL;
    
    if (hFuncScaleMap == NULL)
        hFuncScaleMap = theAPI.zeofunc_GetFunc("calc.HF.ScaleMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarval = theAPI.list_CreateItem(hArgs, VarID_float, "val");
    theAPI.var_SetValue(hVarval, &val);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncScaleMap, hArgs);
    return;
}

void calc_HF_ShiftMap (ZMAP hMap, float val, bool ShowProgress)
{
    static ZFUNC hFuncShiftMap = NULL;
    
    if (hFuncShiftMap == NULL)
        hFuncShiftMap = theAPI.zeofunc_GetFunc("calc.HF.ShiftMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarval = theAPI.list_CreateItem(hArgs, VarID_float, "val");
    theAPI.var_SetValue(hVarval, &val);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncShiftMap, hArgs);
    return;
}

void calc_HF_GradFilter (ZMAP hMap, int nLevels, float Threshold, bool ShowProgress, LPVOID pMaskMap)
{
    static ZFUNC hFuncGradFilter = NULL;
    
    if (hFuncGradFilter == NULL)
        hFuncGradFilter = theAPI.zeofunc_GetFunc("calc.HF.GradFilter");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarnLevels = theAPI.list_CreateItem(hArgs, VarID_int, "nLevels");
    theAPI.var_SetValue(hVarnLevels, &nLevels);

    ZVAR hVarThreshold = theAPI.list_CreateItem(hArgs, VarID_float, "Threshold");
    theAPI.var_SetValue(hVarThreshold, &Threshold);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hVarpMaskMap = theAPI.list_CreateItem(hArgs, VarID_LPVOID, "pMaskMap");
    theAPI.var_SetValue(hVarpMaskMap, &pMaskMap);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGradFilter, hArgs);
    return;
}

void calc_HF_CurvFilter (ZMAP hMap, int nLevels, float Threshold, bool ShowProgress, LPVOID pMaskMap)
{
    static ZFUNC hFuncCurvFilter = NULL;
    
    if (hFuncCurvFilter == NULL)
        hFuncCurvFilter = theAPI.zeofunc_GetFunc("calc.HF.CurvFilter");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarnLevels = theAPI.list_CreateItem(hArgs, VarID_int, "nLevels");
    theAPI.var_SetValue(hVarnLevels, &nLevels);

    ZVAR hVarThreshold = theAPI.list_CreateItem(hArgs, VarID_float, "Threshold");
    theAPI.var_SetValue(hVarThreshold, &Threshold);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hVarpMaskMap = theAPI.list_CreateItem(hArgs, VarID_LPVOID, "pMaskMap");
    theAPI.var_SetValue(hVarpMaskMap, &pMaskMap);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncCurvFilter, hArgs);
    return;
}

void calc_HF_CombineMaps (ZMAP hMap1, ZMAP hMap2, int MixMode, int offset_xmid, int offset_ymid)
{
    static ZFUNC hFuncCombineMaps = NULL;
    
    if (hFuncCombineMaps == NULL)
        hFuncCombineMaps = theAPI.zeofunc_GetFunc("calc.HF.CombineMaps");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap1 = theAPI.list_CreateItem(hArgs, VarID_map, "hMap1");
    theAPI.var_SetValue(hVarhMap1, &hMap1);

    ZVAR hVarhMap2 = theAPI.list_CreateItem(hArgs, VarID_map, "hMap2");
    theAPI.var_SetValue(hVarhMap2, &hMap2);

    ZVAR hVarMixMode = theAPI.list_CreateItem(hArgs, VarID_int, "MixMode");
    theAPI.var_SetValue(hVarMixMode, &MixMode);

    ZVAR hVaroffset_xmid = theAPI.list_CreateItem(hArgs, VarID_int, "offset_xmid");
    theAPI.var_SetValue(hVaroffset_xmid, &offset_xmid);

    ZVAR hVaroffset_ymid = theAPI.list_CreateItem(hArgs, VarID_int, "offset_ymid");
    theAPI.var_SetValue(hVaroffset_ymid, &offset_ymid);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncCombineMaps, hArgs);
    return;
}

void calc_HF_ErodeChannel (ZMAP hMap, int MaxCycles, int MinLength, int MaxLength, float DeltaHF, float MemDecay, bool BlurDir, bool ShowProgress)
{
    static ZFUNC hFuncErodeChannel = NULL;
    
    if (hFuncErodeChannel == NULL)
        hFuncErodeChannel = theAPI.zeofunc_GetFunc("calc.HF.ErodeChannel");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarMaxCycles = theAPI.list_CreateItem(hArgs, VarID_int, "MaxCycles");
    theAPI.var_SetValue(hVarMaxCycles, &MaxCycles);

    ZVAR hVarMinLength = theAPI.list_CreateItem(hArgs, VarID_int, "MinLength");
    theAPI.var_SetValue(hVarMinLength, &MinLength);

    ZVAR hVarMaxLength = theAPI.list_CreateItem(hArgs, VarID_int, "MaxLength");
    theAPI.var_SetValue(hVarMaxLength, &MaxLength);

    ZVAR hVarDeltaHF = theAPI.list_CreateItem(hArgs, VarID_float, "DeltaHF");
    theAPI.var_SetValue(hVarDeltaHF, &DeltaHF);

    ZVAR hVarMemDecay = theAPI.list_CreateItem(hArgs, VarID_float, "MemDecay");
    theAPI.var_SetValue(hVarMemDecay, &MemDecay);

    ZVAR hVarBlurDir = theAPI.list_CreateItem(hArgs, VarID_bool, "BlurDir");
    theAPI.var_SetValue(hVarBlurDir, &BlurDir);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncErodeChannel, hArgs);
    return;
}

void calc_HF_ErodeChannelEx (ZMAP hMap, ZMAP hMaskMap, int MinLength, int MaxLength, float DeltaHF, float MemDecay, bool BlurDir, bool ShowProgress)
{
    static ZFUNC hFuncErodeChannelEx = NULL;
    
    if (hFuncErodeChannelEx == NULL)
        hFuncErodeChannelEx = theAPI.zeofunc_GetFunc("calc.HF.ErodeChannelEx");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarhMaskMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMaskMap");
    theAPI.var_SetValue(hVarhMaskMap, &hMaskMap);

    ZVAR hVarMinLength = theAPI.list_CreateItem(hArgs, VarID_int, "MinLength");
    theAPI.var_SetValue(hVarMinLength, &MinLength);

    ZVAR hVarMaxLength = theAPI.list_CreateItem(hArgs, VarID_int, "MaxLength");
    theAPI.var_SetValue(hVarMaxLength, &MaxLength);

    ZVAR hVarDeltaHF = theAPI.list_CreateItem(hArgs, VarID_float, "DeltaHF");
    theAPI.var_SetValue(hVarDeltaHF, &DeltaHF);

    ZVAR hVarMemDecay = theAPI.list_CreateItem(hArgs, VarID_float, "MemDecay");
    theAPI.var_SetValue(hVarMemDecay, &MemDecay);

    ZVAR hVarBlurDir = theAPI.list_CreateItem(hArgs, VarID_bool, "BlurDir");
    theAPI.var_SetValue(hVarBlurDir, &BlurDir);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncErodeChannelEx, hArgs);
    return;
}

void calc_HF_ErodeThermal (ZMAP hMap, int MaxCycles, int MaxLength, float LossFraction, float GradThreshold, bool ShowProgress)
{
    static ZFUNC hFuncErodeThermal = NULL;
    
    if (hFuncErodeThermal == NULL)
        hFuncErodeThermal = theAPI.zeofunc_GetFunc("calc.HF.ErodeThermal");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarMaxCycles = theAPI.list_CreateItem(hArgs, VarID_int, "MaxCycles");
    theAPI.var_SetValue(hVarMaxCycles, &MaxCycles);

    ZVAR hVarMaxLength = theAPI.list_CreateItem(hArgs, VarID_int, "MaxLength");
    theAPI.var_SetValue(hVarMaxLength, &MaxLength);

    ZVAR hVarLossFraction = theAPI.list_CreateItem(hArgs, VarID_float, "LossFraction");
    theAPI.var_SetValue(hVarLossFraction, &LossFraction);

    ZVAR hVarGradThreshold = theAPI.list_CreateItem(hArgs, VarID_float, "GradThreshold");
    theAPI.var_SetValue(hVarGradThreshold, &GradThreshold);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncErodeThermal, hArgs);
    return;
}

void calc_HF_ErodeThermalEx (ZMAP hMap, ZMAP hMaskMap, int MaxLength, float LossFraction, float GradThreshold, bool ShowProgress)
{
    static ZFUNC hFuncErodeThermalEx = NULL;
    
    if (hFuncErodeThermalEx == NULL)
        hFuncErodeThermalEx = theAPI.zeofunc_GetFunc("calc.HF.ErodeThermalEx");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarhMaskMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMaskMap");
    theAPI.var_SetValue(hVarhMaskMap, &hMaskMap);

    ZVAR hVarMaxLength = theAPI.list_CreateItem(hArgs, VarID_int, "MaxLength");
    theAPI.var_SetValue(hVarMaxLength, &MaxLength);

    ZVAR hVarLossFraction = theAPI.list_CreateItem(hArgs, VarID_float, "LossFraction");
    theAPI.var_SetValue(hVarLossFraction, &LossFraction);

    ZVAR hVarGradThreshold = theAPI.list_CreateItem(hArgs, VarID_float, "GradThreshold");
    theAPI.var_SetValue(hVarGradThreshold, &GradThreshold);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncErodeThermalEx, hArgs);
    return;
}

void calc_HF_Inflate (ZMAP hHF, ZMAP hDM, int levels)
{
    static ZFUNC hFuncInflate = NULL;
    
    if (hFuncInflate == NULL)
        hFuncInflate = theAPI.zeofunc_GetFunc("calc.HF.Inflate");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhHF = theAPI.list_CreateItem(hArgs, VarID_map, "hHF");
    theAPI.var_SetValue(hVarhHF, &hHF);

    ZVAR hVarhDM = theAPI.list_CreateItem(hArgs, VarID_map, "hDM");
    theAPI.var_SetValue(hVarhDM, &hDM);

    ZVAR hVarlevels = theAPI.list_CreateItem(hArgs, VarID_int, "levels");
    theAPI.var_SetValue(hVarlevels, &levels);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncInflate, hArgs);
    return;
}

void calc_HF_InflateMosaic (ZMAP hMapSrc, ZMAP hMapDest, const char * FileName, const char * MapName, int TileSize, ZFORMAT hFormat, ZMAP hDM, int levels)
{
    static ZFUNC hFuncInflateMosaic = NULL;
    
    if (hFuncInflateMosaic == NULL)
        hFuncInflateMosaic = theAPI.zeofunc_GetFunc("calc.HF.InflateMosaic");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMapSrc = theAPI.list_CreateItem(hArgs, VarID_map, "hMapSrc");
    theAPI.var_SetValue(hVarhMapSrc, &hMapSrc);

    ZVAR hVarhMapDest = theAPI.list_CreateItem(hArgs, VarID_map, "hMapDest");
    theAPI.var_SetValue(hVarhMapDest, &hMapDest);

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hVarMapName = theAPI.list_CreateItem(hArgs, VarID_string, "MapName");
    theAPI.str_SetText(hVarMapName, MapName);

    ZVAR hVarTileSize = theAPI.list_CreateItem(hArgs, VarID_int, "TileSize");
    theAPI.var_SetValue(hVarTileSize, &TileSize);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetValue(hVarhFormat, &hFormat);

    ZVAR hVarhDM = theAPI.list_CreateItem(hArgs, VarID_map, "hDM");
    theAPI.var_SetValue(hVarhDM, &hDM);

    ZVAR hVarlevels = theAPI.list_CreateItem(hArgs, VarID_int, "levels");
    theAPI.var_SetValue(hVarlevels, &levels);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncInflateMosaic, hArgs);
    return;
}

bool calc_HF_GenPeakOverlay (ZMAP hMap, int Radius, float Height, int ShapeMode)
{
    static ZFUNC hFuncGenPeakOverlay = NULL;
    
    if (hFuncGenPeakOverlay == NULL)
        hFuncGenPeakOverlay = theAPI.zeofunc_GetFunc("calc.HF.GenPeakOverlay");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarRadius = theAPI.list_CreateItem(hArgs, VarID_int, "Radius");
    theAPI.var_SetValue(hVarRadius, &Radius);

    ZVAR hVarHeight = theAPI.list_CreateItem(hArgs, VarID_float, "Height");
    theAPI.var_SetValue(hVarHeight, &Height);

    ZVAR hVarShapeMode = theAPI.list_CreateItem(hArgs, VarID_int, "ShapeMode");
    theAPI.var_SetValue(hVarShapeMode, &ShapeMode);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGenPeakOverlay, hArgs);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZLIST calc_AM_GetFilterList ()
{
    static ZFUNC hFuncGetFilterList = NULL;
    
    if (hFuncGetFilterList == NULL)
        hFuncGetFilterList = theAPI.zeofunc_GetFunc("calc.AM.GetFilterList");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetFilterList, NULL);
    
    ZLIST retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
short calc_AM_FilterPixel (short InputCode, ZVAR Buf, ZLIST Filter)
{
    static ZFUNC hFuncFilterPixel = NULL;
    
    if (hFuncFilterPixel == NULL)
        hFuncFilterPixel = theAPI.zeofunc_GetFunc("calc.AM.FilterPixel");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hVarBuf = theAPI.list_CreateItem(hArgs, VarID_buffer, "Buf");
    theAPI.var_SetValue(hVarBuf, &Buf);

    ZVAR hVarFilter = theAPI.list_CreateItem(hArgs, VarID_varlist, "Filter");
    theAPI.var_SetValue(hVarFilter, &Filter);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncFilterPixel, hArgs);
    
    short retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZVAR calc_AM_GetClimateByCode (short InputCode)
{
    static ZFUNC hFuncGetClimateByCode = NULL;
    
    if (hFuncGetClimateByCode == NULL)
        hFuncGetClimateByCode = theAPI.zeofunc_GetFunc("calc.AM.GetClimateByCode");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetClimateByCode, hArgs);
    
    ZVAR retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZVAR calc_AM_GetLandTypeByCode (short InputCode)
{
    static ZFUNC hFuncGetLandTypeByCode = NULL;
    
    if (hFuncGetLandTypeByCode == NULL)
        hFuncGetLandTypeByCode = theAPI.zeofunc_GetFunc("calc.AM.GetLandTypeByCode");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetLandTypeByCode, hArgs);
    
    ZVAR retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZVAR calc_AM_GetPixelColour (short InputCode)
{
    static ZFUNC hFuncGetPixelColour = NULL;
    
    if (hFuncGetPixelColour == NULL)
        hFuncGetPixelColour = theAPI.zeofunc_GetFunc("calc.AM.GetPixelColour");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetPixelColour, hArgs);
    
    ZVAR retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

short calc_AM_GetIDfromColour (ZVAR InputColour)
{
    static ZFUNC hFuncGetIDfromColour = NULL;
    
    if (hFuncGetIDfromColour == NULL)
        hFuncGetIDfromColour = theAPI.zeofunc_GetFunc("calc.AM.GetIDfromColour");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarInputColour = theAPI.list_CreateItem(hArgs, VarID_colour, "InputColour");
    theAPI.var_SetValue(hVarInputColour, &InputColour);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetIDfromColour, hArgs);
    
    short retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

void calc_AM_GenMap ()
{
    static ZFUNC hFuncGenMap = NULL;
    
    if (hFuncGenMap == NULL)
        hFuncGenMap = theAPI.zeofunc_GetFunc("calc.AM.GenMap");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGenMap, NULL);
    return;
}
void calc_TN_GenMap ()
{
    static ZFUNC hFuncGenMap = NULL;
    
    if (hFuncGenMap == NULL)
        hFuncGenMap = theAPI.zeofunc_GetFunc("calc.TN.GenMap");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGenMap, NULL);
    return;
}
bool calc_TN_GenArea (int TileStateFlag, ZLIST maps, ZLIST area, ZLIST params, ZLIST prog)
{
    static ZFUNC hFuncGenArea = NULL;
    
    if (hFuncGenArea == NULL)
        hFuncGenArea = theAPI.zeofunc_GetFunc("calc.TN.GenArea");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarTileStateFlag = theAPI.list_CreateItem(hArgs, VarID_int, "TileStateFlag");
    theAPI.var_SetValue(hVarTileStateFlag, &TileStateFlag);

    ZVAR hVarmaps = theAPI.list_CreateItem(hArgs, VarID_varlist, "maps");
    theAPI.var_SetValue(hVarmaps, &maps);

    ZVAR hVararea = theAPI.list_CreateItem(hArgs, VarID_varlist, "area");
    theAPI.var_SetValue(hVararea, &area);

    ZVAR hVarparams = theAPI.list_CreateItem(hArgs, VarID_varlist, "params");
    theAPI.var_SetValue(hVarparams, &params);

    ZVAR hVarprog = theAPI.list_CreateItem(hArgs, VarID_varlist, "prog");
    theAPI.var_SetValue(hVarprog, &prog);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGenArea, hArgs);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

void calc_LM_GenMap ()
{
    static ZFUNC hFuncGenMap = NULL;
    
    if (hFuncGenMap == NULL)
        hFuncGenMap = theAPI.zeofunc_GetFunc("calc.LM.GenMap");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGenMap, NULL);
    return;
}
void calc_TX_GenMap ()
{
    static ZFUNC hFuncGenMap = NULL;
    
    if (hFuncGenMap == NULL)
        hFuncGenMap = theAPI.zeofunc_GetFunc("calc.TX.GenMap");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGenMap, NULL);
    return;
}
bool calc_TX_GenMapPro_CalcArea (int TileStateFlag, ZLIST maps, ZLIST area, ZLIST params, ZLIST prog)
{
    static ZFUNC hFuncCalcArea = NULL;
    
    if (hFuncCalcArea == NULL)
        hFuncCalcArea = theAPI.zeofunc_GetFunc("calc.TX.GenMapPro.CalcArea");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarTileStateFlag = theAPI.list_CreateItem(hArgs, VarID_int, "TileStateFlag");
    theAPI.var_SetValue(hVarTileStateFlag, &TileStateFlag);

    ZVAR hVarmaps = theAPI.list_CreateItem(hArgs, VarID_varlist, "maps");
    theAPI.var_SetValue(hVarmaps, &maps);

    ZVAR hVararea = theAPI.list_CreateItem(hArgs, VarID_varlist, "area");
    theAPI.var_SetValue(hVararea, &area);

    ZVAR hVarparams = theAPI.list_CreateItem(hArgs, VarID_varlist, "params");
    theAPI.var_SetValue(hVarparams, &params);

    ZVAR hVarprog = theAPI.list_CreateItem(hArgs, VarID_varlist, "prog");
    theAPI.var_SetValue(hVarprog, &prog);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncCalcArea, hArgs);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZLIST calc_alpha_ExportExpress (const char * FileName, ZMAP hMap, ZLIST hFilter, ZFORMAT hFormat, int LayersPerImage, bool MosaicFlag, int TileSize, bool ShowReport)
{
    static ZFUNC hFuncExportExpress = NULL;
    
    if (hFuncExportExpress == NULL)
        hFuncExportExpress = theAPI.zeofunc_GetFunc("calc.alpha.ExportExpress");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarhFilter = theAPI.list_CreateItem(hArgs, VarID_varlist, "hFilter");
    theAPI.var_SetValue(hVarhFilter, &hFilter);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetValue(hVarhFormat, &hFormat);

    ZVAR hVarLayersPerImage = theAPI.list_CreateItem(hArgs, VarID_int, "LayersPerImage");
    theAPI.var_SetValue(hVarLayersPerImage, &LayersPerImage);

    ZVAR hVarMosaicFlag = theAPI.list_CreateItem(hArgs, VarID_bool, "MosaicFlag");
    theAPI.var_SetValue(hVarMosaicFlag, &MosaicFlag);

    ZVAR hVarTileSize = theAPI.list_CreateItem(hArgs, VarID_int, "TileSize");
    theAPI.var_SetValue(hVarTileSize, &TileSize);

    ZVAR hVarShowReport = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowReport");
    theAPI.var_SetValue(hVarShowReport, &ShowReport);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExportExpress, hArgs);
    
    ZLIST retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

const char * classes_landtype_GetBaseTextureNameByID (short InputCode)
{
    static ZFUNC hFuncGetBaseTextureNameByID = NULL;
    
    if (hFuncGetBaseTextureNameByID == NULL)
        hFuncGetBaseTextureNameByID = theAPI.zeofunc_GetFunc("classes.landtype.GetBaseTextureNameByID");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetBaseTextureNameByID, hArgs);
    
    const char * retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

const char * classes_landtype_GetTypeNameByID (short InputCode)
{
    static ZFUNC hFuncGetTypeNameByID = NULL;
    
    if (hFuncGetTypeNameByID == NULL)
        hFuncGetTypeNameByID = theAPI.zeofunc_GetFunc("classes.landtype.GetTypeNameByID");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetTypeNameByID, hArgs);
    
    const char * retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

const char * classes_landtype_GetName (ZVAR hLandType)
{
    static ZFUNC hFuncGetName = NULL;
    
    if (hFuncGetName == NULL)
        hFuncGetName = theAPI.zeofunc_GetFunc("classes.landtype.GetName");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhLandType = theAPI.list_CreateItem(hArgs, VarID_LandType, "hLandType");
    theAPI.var_SetValue(hVarhLandType, &hLandType);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetName, hArgs);
    
    const char * retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZFORMAT classes_format_GetActiveFormat (const char * MapName, int MapTypeID)
{
    static ZFUNC hFuncGetActiveFormat = NULL;
    
    if (hFuncGetActiveFormat == NULL)
        hFuncGetActiveFormat = theAPI.zeofunc_GetFunc("classes.format.GetActiveFormat");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarMapName = theAPI.list_CreateItem(hArgs, VarID_string, "MapName");
    theAPI.str_SetText(hVarMapName, MapName);

    ZVAR hVarMapTypeID = theAPI.list_CreateItem(hArgs, VarID_int, "MapTypeID");
    theAPI.var_SetValue(hVarMapTypeID, &MapTypeID);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetActiveFormat, hArgs);
    
    ZFORMAT retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZLIST classes_climate_GetTypeList (ZVAR hClimate)
{
    static ZFUNC hFuncGetTypeList = NULL;
    
    if (hFuncGetTypeList == NULL)
        hFuncGetTypeList = theAPI.zeofunc_GetFunc("classes.climate.GetTypeList");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhClimate = theAPI.list_CreateItem(hArgs, VarID_Climate, "hClimate");
    theAPI.var_SetValue(hVarhClimate, &hClimate);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetTypeList, hArgs);
    
    ZLIST retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

const char * classes_climate_GetName (ZVAR hClimate)
{
    static ZFUNC hFuncGetName = NULL;
    
    if (hFuncGetName == NULL)
        hFuncGetName = theAPI.zeofunc_GetFunc("classes.climate.GetName");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhClimate = theAPI.list_CreateItem(hArgs, VarID_Climate, "hClimate");
    theAPI.var_SetValue(hVarhClimate, &hClimate);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetName, hArgs);
    
    const char * retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

bool threadman_RunTiles (ZFUNC hTileFn, ZLIST TileList)
{
    static ZFUNC hFuncRunTiles = NULL;
    
    if (hFuncRunTiles == NULL)
        hFuncRunTiles = theAPI.zeofunc_GetFunc("threadman.RunTiles");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhTileFn = theAPI.list_CreateItem(hArgs, VarID_ZeoFunc, "hTileFn");
    theAPI.var_SetValue(hVarhTileFn, &hTileFn);

    ZVAR hVarTileList = theAPI.list_CreateItem(hArgs, VarID_varlist, "TileList");
    theAPI.var_SetValue(hVarTileList, &TileList);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncRunTiles, hArgs);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZLIST zeofunc_GetFuncList ()
{
    static ZFUNC hFuncGetFuncList = NULL;
    
    if (hFuncGetFuncList == NULL)
        hFuncGetFuncList = theAPI.zeofunc_GetFunc("zeofunc.GetFuncList");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetFuncList, NULL);
    
    ZLIST retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
const char * application_GetTempDir ()
{
    static ZFUNC hFuncGetTempDir = NULL;
    
    if (hFuncGetTempDir == NULL)
        hFuncGetTempDir = theAPI.zeofunc_GetFunc("application.GetTempDir");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetTempDir, NULL);
    
    const char * retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
int application_GetUID ()
{
    static ZFUNC hFuncGetUID = NULL;
    
    if (hFuncGetUID == NULL)
        hFuncGetUID = theAPI.zeofunc_GetFunc("application.GetUID");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetUID, NULL);
    
    int retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
bool project_IsInit ()
{
    static ZFUNC hFuncIsInit = NULL;
    
    if (hFuncIsInit == NULL)
        hFuncIsInit = theAPI.zeofunc_GetFunc("project.IsInit");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncIsInit, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
bool project_InitProject ()
{
    static ZFUNC hFuncInitProject = NULL;
    
    if (hFuncInitProject == NULL)
        hFuncInitProject = theAPI.zeofunc_GetFunc("project.InitProject");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncInitProject, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
bool project_FreeProject ()
{
    static ZFUNC hFuncFreeProject = NULL;
    
    if (hFuncFreeProject == NULL)
        hFuncFreeProject = theAPI.zeofunc_GetFunc("project.FreeProject");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncFreeProject, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
const char * project_GetProjectPath ()
{
    static ZFUNC hFuncGetProjectPath = NULL;
    
    if (hFuncGetProjectPath == NULL)
        hFuncGetProjectPath = theAPI.zeofunc_GetFunc("project.GetProjectPath");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetProjectPath, NULL);
    
    const char * retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
LPVOID project_GetMap (const char * MapName)
{
    static ZFUNC hFuncGetMap = NULL;
    
    if (hFuncGetMap == NULL)
        hFuncGetMap = theAPI.zeofunc_GetFunc("project.GetMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarMapName = theAPI.list_CreateItem(hArgs, VarID_string, "MapName");
    theAPI.str_SetText(hVarMapName, MapName);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetMap, hArgs);
    
    LPVOID retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZLIST project_GetSettingsList ()
{
    static ZFUNC hFuncGetSettingsList = NULL;
    
    if (hFuncGetSettingsList == NULL)
        hFuncGetSettingsList = theAPI.zeofunc_GetFunc("project.GetSettingsList");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetSettingsList, NULL);
    
    ZLIST retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
ZLIST project_GetHeightfieldRange ()
{
    static ZFUNC hFuncGetHeightfieldRange = NULL;
    
    if (hFuncGetHeightfieldRange == NULL)
        hFuncGetHeightfieldRange = theAPI.zeofunc_GetFunc("project.GetHeightfieldRange");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetHeightfieldRange, NULL);
    
    ZLIST retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
void file_export_atlasEx (ZLIST MapList, const char * FileName, ZLIST Options)
{
    static ZFUNC hFuncatlasEx = NULL;
    
    if (hFuncatlasEx == NULL)
        hFuncatlasEx = theAPI.zeofunc_GetFunc("file.export.atlasEx");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarMapList = theAPI.list_CreateItem(hArgs, VarID_varlist, "MapList");
    theAPI.var_SetValue(hVarMapList, &MapList);

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hVarOptions = theAPI.list_CreateItem(hArgs, VarID_varlist, "Options");
    theAPI.var_SetValue(hVarOptions, &Options);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncatlasEx, hArgs);
    return;
}

bool file_export_area (ZMAP hMap, const char * FileName, ZFORMAT hFormat, int x1, int x2, int y1, int y2)
{
    static ZFUNC hFuncarea = NULL;
    
    if (hFuncarea == NULL)
        hFuncarea = theAPI.zeofunc_GetFunc("file.export.area");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetValue(hVarhFormat, &hFormat);

    ZVAR hVarx1 = theAPI.list_CreateItem(hArgs, VarID_int, "x1");
    theAPI.var_SetValue(hVarx1, &x1);

    ZVAR hVarx2 = theAPI.list_CreateItem(hArgs, VarID_int, "x2");
    theAPI.var_SetValue(hVarx2, &x2);

    ZVAR hVary1 = theAPI.list_CreateItem(hArgs, VarID_int, "y1");
    theAPI.var_SetValue(hVary1, &y1);

    ZVAR hVary2 = theAPI.list_CreateItem(hArgs, VarID_int, "y2");
    theAPI.var_SetValue(hVary2, &y2);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncarea, hArgs);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

ZLIST climate_GetClimateList ()
{
    static ZFUNC hFuncGetClimateList = NULL;
    
    if (hFuncGetClimateList == NULL)
        hFuncGetClimateList = theAPI.zeofunc_GetFunc("climate.GetClimateList");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncGetClimateList, NULL);
    
    ZLIST retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
void Sapphire_ExtRenderHF ()
{
    static ZFUNC hFuncExtRenderHF = NULL;
    
    if (hFuncExtRenderHF == NULL)
        hFuncExtRenderHF = theAPI.zeofunc_GetFunc("Sapphire.ExtRenderHF");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtRenderHF, NULL);
    return;
}
void Sapphire_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("Sapphire.ExtWikiPage");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtWikiPage, NULL);
    return;
}
void CopyPaste_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("CopyPaste.ExtAbout");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtAbout, NULL);
    return;
}
void CopyPaste_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("CopyPaste.ExtWikiPage");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtWikiPage, NULL);
    return;
}
void CopyPaste_ExtToggleWnd ()
{
    static ZFUNC hFuncExtToggleWnd = NULL;
    
    if (hFuncExtToggleWnd == NULL)
        hFuncExtToggleWnd = theAPI.zeofunc_GetFunc("CopyPaste.ExtToggleWnd");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtToggleWnd, NULL);
    return;
}
bool edit_copy ()
{
    static ZFUNC hFunccopy = NULL;
    
    if (hFunccopy == NULL)
        hFunccopy = theAPI.zeofunc_GetFunc("edit.copy");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFunccopy, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
bool edit_paste ()
{
    static ZFUNC hFuncpaste = NULL;
    
    if (hFuncpaste == NULL)
        hFuncpaste = theAPI.zeofunc_GetFunc("edit.paste");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncpaste, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
void atExportArea_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("atExportArea.ExtAbout");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtAbout, NULL);
    return;
}
bool atExportArea_ExtExportAreaUI ()
{
    static ZFUNC hFuncExtExportAreaUI = NULL;
    
    if (hFuncExtExportAreaUI == NULL)
        hFuncExtExportAreaUI = theAPI.zeofunc_GetFunc("atExportArea.ExtExportAreaUI");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtExportAreaUI, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
bool atExportArea_ExtExportAreaUIEx ()
{
    static ZFUNC hFuncExtExportAreaUIEx = NULL;
    
    if (hFuncExtExportAreaUIEx == NULL)
        hFuncExtExportAreaUIEx = theAPI.zeofunc_GetFunc("atExportArea.ExtExportAreaUIEx");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtExportAreaUIEx, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
void atFilterAM_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("atFilterAM.ExtAbout");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtAbout, NULL);
    return;
}
void atFilterAM_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("atFilterAM.ExtWikiPage");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtWikiPage, NULL);
    return;
}
void atFilterAM_ExtFilterAM ()
{
    static ZFUNC hFuncExtFilterAM = NULL;
    
    if (hFuncExtFilterAM == NULL)
        hFuncExtFilterAM = theAPI.zeofunc_GetFunc("atFilterAM.ExtFilterAM");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtFilterAM, NULL);
    return;
}
void atFilterAM_ExtAlphaExpress_UI ()
{
    static ZFUNC hFuncExtAlphaExpress_UI = NULL;
    
    if (hFuncExtAlphaExpress_UI == NULL)
        hFuncExtAlphaExpress_UI = theAPI.zeofunc_GetFunc("atFilterAM.ExtAlphaExpress.UI");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtAlphaExpress_UI, NULL);
    return;
}
bool atFilterAM_ExtEditFilterList ()
{
    static ZFUNC hFuncExtEditFilterList = NULL;
    
    if (hFuncExtEditFilterList == NULL)
        hFuncExtEditFilterList = theAPI.zeofunc_GetFunc("atFilterAM.ExtEditFilterList");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtEditFilterList, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
void atGrowTilesByOne_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtAbout");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtAbout, NULL);
    return;
}
void atGrowTilesByOne_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtWikiPage");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtWikiPage, NULL);
    return;
}
bool atGrowTilesByOne_ExtGrowTilesByOne (ZMAP hMap, const char * FileNameStr, ZFORMAT hFormat)
{
    static ZFUNC hFuncExtGrowTilesByOne = NULL;
    
    if (hFuncExtGrowTilesByOne == NULL)
        hFuncExtGrowTilesByOne = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtGrowTilesByOne");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarFileNameStr = theAPI.list_CreateItem(hArgs, VarID_string, "FileNameStr");
    theAPI.str_SetText(hVarFileNameStr, FileNameStr);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetValue(hVarhFormat, &hFormat);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtGrowTilesByOne, hArgs);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

bool atGrowTilesByOne_ExtGrowMapByOne (ZMAP hMap, const char * FileNameStr, ZFORMAT hFormat)
{
    static ZFUNC hFuncExtGrowMapByOne = NULL;
    
    if (hFuncExtGrowMapByOne == NULL)
        hFuncExtGrowMapByOne = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtGrowMapByOne");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetValue(hVarhMap, &hMap);

    ZVAR hVarFileNameStr = theAPI.list_CreateItem(hArgs, VarID_string, "FileNameStr");
    theAPI.str_SetText(hVarFileNameStr, FileNameStr);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetValue(hVarhFormat, &hFormat);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtGrowMapByOne, hArgs);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}

bool atGrowTilesByOne_ExtGrowMapByOneUI ()
{
    static ZFUNC hFuncExtGrowMapByOneUI = NULL;
    
    if (hFuncExtGrowMapByOneUI == NULL)
        hFuncExtGrowMapByOneUI = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtGrowMapByOneUI");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtGrowMapByOneUI, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
bool atGrowTilesByOne_ExtGrowTilesByOneUI ()
{
    static ZFUNC hFuncExtGrowTilesByOneUI = NULL;
    
    if (hFuncExtGrowTilesByOneUI == NULL)
        hFuncExtGrowTilesByOneUI = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtGrowTilesByOneUI");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtGrowTilesByOneUI, NULL);
    
    bool retValue;
    theAPI.var_GetValue(hRetVar, &retValue);
    return retValue;

}
void atFuncBrowser_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("atFuncBrowser.ExtWikiPage");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtWikiPage, NULL);
    return;
}
void atFuncBrowser_ExtShowFuncBrowser ()
{
    static ZFUNC hFuncExtShowFuncBrowser = NULL;
    
    if (hFuncExtShowFuncBrowser == NULL)
        hFuncExtShowFuncBrowser = theAPI.zeofunc_GetFunc("atFuncBrowser.ExtShowFuncBrowser");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtShowFuncBrowser, NULL);
    return;
}
void atFuncBrowser_ExtHideFuncBrowser ()
{
    static ZFUNC hFuncExtHideFuncBrowser = NULL;
    
    if (hFuncExtHideFuncBrowser == NULL)
        hFuncExtHideFuncBrowser = theAPI.zeofunc_GetFunc("atFuncBrowser.ExtHideFuncBrowser");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtHideFuncBrowser, NULL);
    return;
}
void atFuncBrowser_ExtToggleFuncBrowser ()
{
    static ZFUNC hFuncExtToggleFuncBrowser = NULL;
    
    if (hFuncExtToggleFuncBrowser == NULL)
        hFuncExtToggleFuncBrowser = theAPI.zeofunc_GetFunc("atFuncBrowser.ExtToggleFuncBrowser");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtToggleFuncBrowser, NULL);
    return;
}
void cdPython_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("cdPython.ExtAbout");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtAbout, NULL);
    return;
}
void cdPython_LoadScriptUI ()
{
    static ZFUNC hFuncLoadScriptUI = NULL;
    
    if (hFuncLoadScriptUI == NULL)
        hFuncLoadScriptUI = theAPI.zeofunc_GetFunc("cdPython.LoadScriptUI");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncLoadScriptUI, NULL);
    return;
}
void cdPython_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("cdPython.ExtWikiPage");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtWikiPage, NULL);
    return;
}
void cdPython_ExtZeoPage ()
{
    static ZFUNC hFuncExtZeoPage = NULL;
    
    if (hFuncExtZeoPage == NULL)
        hFuncExtZeoPage = theAPI.zeofunc_GetFunc("cdPython.ExtZeoPage");

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncExtZeoPage, NULL);
    return;
}
void cdPython_LoadScript (const char * FileName)
{
    static ZFUNC hFuncLoadScript = NULL;
    
    if (hFuncLoadScript == NULL)
        hFuncLoadScript = theAPI.zeofunc_GetFunc("cdPython.LoadScript");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncLoadScript, hArgs);
    return;
}

void cdPython_RunScript (const char * ScriptStr)
{
    static ZFUNC hFuncRunScript = NULL;
    
    if (hFuncRunScript == NULL)
        hFuncRunScript = theAPI.zeofunc_GetFunc("cdPython.RunScript");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    /* create all the args here */

    ZVAR hVarScriptStr = theAPI.list_CreateItem(hArgs, VarID_string, "ScriptStr");
    theAPI.str_SetText(hVarScriptStr, ScriptStr);

    ZVAR hRetVar = theAPI.zeofunc_Execute(hFuncRunScript, hArgs);
    return;
}

/* EOF */

